import os
import re
from decimal import Decimal, InvalidOperation, getcontext
from typing import Dict, List, Tuple, Optional, Any

from langchain_chroma import Chroma
from langchain_community.embeddings import DashScopeEmbeddings
from langchain_openai import ChatOpenAI
from langchain_community.document_loaders import TextLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter

# ============================================================================
# 全局配置和初始化
# ============================================================================

def initialize_llm() -> ChatOpenAI:
    """
    初始化通义千问大语言模型
    
    Returns:
        ChatOpenAI: 配置好的LLM实例
    """
    return ChatOpenAI(
        api_key="sk-b5a1d95d5595453dbafb47db0a80d4be",
        base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
        model="qwen-max"
    )

def initialize_embedding() -> DashScopeEmbeddings:
    """
    初始化DashScope嵌入模型
    
    Returns:
        DashScopeEmbeddings: 配置好的嵌入模型实例
    """
    return DashScopeEmbeddings(
        model="text-embedding-v2",
        dashscope_api_key=os.getenv("DASHSCOPE_API_KEY", "sk-b5a1d95d5595453dbafb47db0a80d4be")
    )

def initialize_vector_db(embedding_function: DashScopeEmbeddings) -> Chroma:
    """
    初始化Chroma向量数据库
    
    Args:
        embedding_function: 嵌入函数实例
        
    Returns:
        Chroma: 配置好的向量数据库实例
    """
    return Chroma(
        embedding_function=embedding_function,
        collection_metadata={"hnsw:space": "cosine"},
        persist_directory="./chroma_db"
    )

# 初始化全局实例
llm = initialize_llm()
embedding = initialize_embedding()
db = initialize_vector_db(embedding)

# ============================================================================
# 文档处理相关方法
# ============================================================================

def load_document(file_path: str) -> List[Any]:
    """
    加载文档文件
    
    Args:
        file_path: 文档文件路径
        
    Returns:
        List[Any]: 加载的文档列表
        
    Raises:
        Exception: 文档加载失败时抛出异常
    """
    try:
        loader = TextLoader(file_path, encoding='utf-8')
        documents = loader.load()
        print(f"成功加载文档，共 {len(documents)} 个文档")
        return documents
    except Exception as e:
        print(f"文档加载失败: {e}")
        raise

def create_text_splitter() -> RecursiveCharacterTextSplitter:
    """
    创建文本分割器
    
    Returns:
        RecursiveCharacterTextSplitter: 配置好的文本分割器
    """
    return RecursiveCharacterTextSplitter(
        chunk_size=1000,
        chunk_overlap=200,
        length_function=len,
        separators=["\n\n", "\n", "。", "！", "？", ";", ":", "，", " ", ""],
        keep_separator=True,
        is_separator_regex=False,
        strip_whitespace=True,
    )

def split_documents(documents: List[Any], text_splitter: RecursiveCharacterTextSplitter) -> List[Any]:
    """
    分割文档为文本块
    
    Args:
        documents: 原始文档列表
        text_splitter: 文本分割器实例
        
    Returns:
        List[Any]: 分割后的文本块列表
    """
    splits = text_splitter.split_documents(documents)
    print(f"文档分割完成，共 {len(splits)} 个文本块")
    return splits

def load_document_and_split(file_path: str) -> Tuple[List[Any], List[Any]]:
    """
    加载文档并分割成文本块
    
    Args:
        file_path: 文档文件路径
        
    Returns:
        Tuple[List[Any], List[Any]]: (原始文档列表, 分割后的文本块列表)
    """
    documents = load_document(file_path)
    text_splitter = create_text_splitter()
    splits = split_documents(documents, text_splitter)
    return documents, splits

# ============================================================================
# 成本信息解析相关方法
# ============================================================================

def setup_decimal_precision() -> None:
    """
    设置Decimal精度
    """
    getcontext().prec = 50

def create_cost_regex_pattern() -> str:
    """
    创建用于匹配骑手成本信息的正则表达式模式
    
    Returns:
        str: 正则表达式模式字符串
    """
    return (
        r"^\s*"                              # 行首
        r"(\d+)[\.．、]\s*"             # 序号+分隔符
        r"骑手(\d+)"                           # 骑手ID
        r"[（(]([^）)]+)[）)]"                    # 括号内代码
        r"[\s，,]*"                            # 可选逗号/空白
        r"总成本[：:]*\s*"                      # 标签+可选冒号
        r"([0-9]+(?:\.[0-9]+)?(?:[eE][+-]?\d+)?)"  # 数值（含科学计数法）
        r"[\s，,]*"                            # 可选逗号/空白
        r"(?:业务(?:评分)?(?:系数|优先级))[：:]*\s*"   # 业务评分系数/业务优先级
        r"(.+?)(?:。|\r?\n|$)"                 # 评分系数内容，直到句号/换行/结尾
    )

def parse_business_factors(business_factors: str) -> Dict[str, float]:
    """
    解析业务评分系数字符串
    
    Args:
        business_factors: 业务评分系数字符串
        
    Returns:
        Dict[str, float]: 解析后的评分系数字典
    """
    factors_dict = {}
    if not business_factors:
        return factors_dict
        
    factor_parts = business_factors.split("::")
    for part in factor_parts:
        if "_PRIORITY_" in part and part.strip():
            try:
                factor_name, factor_value = part.rsplit("_", 1)
                if factor_value.replace(".", "").replace("-", "").isdigit():
                    factors_dict[factor_name.strip()] = float(factor_value)
            except Exception:
                continue
    return factors_dict

def extract_single_rider_cost(match: re.Match) -> Optional[Dict[str, Any]]:
    """
    从正则匹配结果中提取单个骑手的成本信息
    
    Args:
        match: 正则表达式匹配对象
        
    Returns:
        Optional[Dict[str, Any]]: 骑手成本信息字典，解析失败时返回None
    """
    try:
        rank, rider_id, rider_code, cost_str, business_factors = match.groups()
        print(f"匹配到骑手: rank={rank}, rider_id={rider_id}, rider_code={rider_code}, cost_str={cost_str}")
        
        cost = Decimal(cost_str)
        factors_dict = parse_business_factors(business_factors)
        
        return {
            'rank': int(rank),
            'rider_id': rider_id,
            'rider_code': rider_code,
            'total_cost': float(cost),
            'business_factors': factors_dict
        }
    except Exception as e:
        print(f"解析骑手成本信息失败: {e}")
        return None

def debug_cost_parsing(content: str) -> None:
    """
    调试成本解析，显示相关内容样本
    
    Args:
        content: 要调试的内容字符串
    """
    idx = content.find("【配送成本日志信息】")
    start = max(0, idx - 400) if idx != -1 else 0
    end = min(len(content), (idx + 2000) if idx != -1 else 2000)
    sample = content[start:end]
    print(f"未找到匹配，展示成本日志附近样本：\n{sample}")

def extract_rider_cost_info(content: str) -> Dict[str, Dict[str, Any]]:
    """
    从内容中提取骑手成本信息
    
    Args:
        content: 包含骑手成本信息的文本内容
        
    Returns:
        Dict[str, Dict[str, Any]]: 骑手ID到成本信息的映射字典
    """
    setup_decimal_precision()
    cost_info = {}
    
    pattern = create_cost_regex_pattern()
    print(f"开始解析成本信息，内容长度: {len(content)}")
    
    matches = list(re.finditer(pattern, content, flags=re.MULTILINE))
    print(f"找到 {len(matches)} 个匹配项")
    
    if not matches:
        debug_cost_parsing(content)
        return cost_info
    
    for match in matches:
        rider_info = extract_single_rider_cost(match)
        if rider_info:
            cost_info[rider_info['rider_id']] = rider_info
    
    print(f"最终解析到 {len(cost_info)} 个骑手的成本信息")
    return cost_info

# ============================================================================
# 查询结果评分相关方法
# ============================================================================

def calculate_base_score(result: str) -> int:
    """
    计算查询结果的基础分数
    
    Args:
        result: 查询结果字符串
        
    Returns:
        int: 基础分数（基于文本长度）
    """
    return len(result)

def calculate_rider_id_bonus(result: str, rider_id: str) -> int:
    """
    计算包含骑手ID的加分
    
    Args:
        result: 查询结果字符串
        rider_id: 骑手ID
        
    Returns:
        int: 骑手ID相关的加分
    """
    return 500 if rider_id in result else 0

def calculate_keyword_bonus(result: str, keywords: List[str]) -> int:
    """
    计算关键词匹配的加分
    
    Args:
        result: 查询结果字符串
        keywords: 关键词列表
        
    Returns:
        int: 关键词匹配的总加分
    """
    bonus = 0
    for keyword in keywords:
        if keyword in result:
            bonus += 100
    return bonus

def evaluate_query_result_quality(result: str, rider_id: str, keywords: List[str] = None) -> int:
    """
    评估查询结果的质量分数
    
    Args:
        result: 查询结果字符串
        rider_id: 相关骑手ID
        keywords: 关键词列表，默认为常用分析关键词
        
    Returns:
        int: 质量评分
    """
    if not result or "出错" in result or "未找到" in result:
        return 0
    
    if keywords is None:
        keywords = ["排除", "过滤", "距离", "成本", "派送", "订单"]
    
    score = calculate_base_score(result)
    score += calculate_rider_id_bonus(result, rider_id)
    score += calculate_keyword_bonus(result, keywords)
    
    return score

def evaluate_comparison_result_quality(result: str, rider_id: str, winner_rider_id: str, 
                                     order_id: str) -> int:
    """
    评估对比查询结果的质量分数
    
    Args:
        result: 查询结果字符串
        rider_id: 要分析的骑手ID
        winner_rider_id: 成功骑手ID
        order_id: 订单ID
        
    Returns:
        int: 质量评分
    """
    if not result or "出错" in result or "未找到" in result:
        return 0
    
    score = calculate_base_score(result)
    
    # 骑手ID相关加分
    if rider_id in result and winner_rider_id in result:
        score += 1000
    elif rider_id in result or winner_rider_id in result:
        score += 500
    
    # 订单ID相关加分
    if order_id in result or "35863807" in result:
        score += 300
    
    # 对比相关关键词加分
    comparison_keywords = ["比较", "差异", "优势", "劣势", "成本", "距离", "评分", "过滤", "排除"]
    score += calculate_keyword_bonus(result, comparison_keywords)
    
    return score

# ============================================================================
# 查询模板生成相关方法
# ============================================================================

def generate_rider_query_templates(rider_id: str) -> List[str]:
    """
    生成骑手查询的模板列表
    
    Args:
        rider_id: 骑手ID
        
    Returns:
        List[str]: 查询模板列表
    """
    return [
        f"为什么骑手{rider_id}没有被选中",
        f"骑手{rider_id}为什么没有接到订单",
        f"分析骑手{rider_id}的派单情况",
        f"骑手{rider_id}的成本分析"
    ]

def generate_comparison_query_templates(rider_id: str, winner_rider_id: str, order_id: str) -> List[str]:
    """
    生成骑手对比查询的模板列表
    
    Args:
        rider_id: 要分析的骑手ID
        winner_rider_id: 成功骑手ID
        order_id: 订单ID
        
    Returns:
        List[str]: 对比查询模板列表
    """
    return [
        f"为什么骑手{rider_id}没有获得订单{order_id}，而骑手{winner_rider_id}成功获得了",
        f"比较骑手{rider_id}和骑手{winner_rider_id}在订单{order_id}上的差异",
        f"分析骑手{rider_id}相比骑手{winner_rider_id}的劣势",
        f"骑手{rider_id}为什么输给了骑手{winner_rider_id}"
    ]

# ============================================================================
# 核心查询方法
# ============================================================================

def detect_cost_related_question(user_question: str) -> bool:
    """
    检测用户问题是否与成本相关
    
    Args:
        user_question: 用户问题
        
    Returns:
        bool: 是否为成本相关问题
    """
    cost_keywords = ["成本", "费用", "价格", "评分", "排名"]
    return any(keyword in user_question for keyword in cost_keywords)

def perform_similarity_search(user_question: str, k: int = 5) -> List[Any]:
    """
    执行相似性搜索
    
    Args:
        user_question: 用户问题
        k: 返回的相似文档数量
        
    Returns:
        List[Any]: 相似文档列表
    """
    return db.similarity_search(user_question, k=k)

def create_context_from_docs(docs: List[Any]) -> str:
    """
    从文档列表创建上下文字符串
    
    Args:
        docs: 文档列表
        
    Returns:
        str: 合并的上下文字符串
    """
    return "\n\n".join([doc.page_content for doc in docs])

def create_analysis_prompt(user_question: str, context: str) -> str:
    """
    创建分析提示词
    
    Args:
        user_question: 用户问题
        context: 上下文信息
        
    Returns:
        str: 完整的分析提示词
    """
    return f"""基于以下文档内容，请详细分析并回答用户的问题。

用户问题：{user_question}

相关文档内容：
{context}

请提供详细的分析，包括：
1. 直接回答用户的问题
2. 分析相关的原因和背景
3. 如果涉及骑手派单，请说明具体的过滤条件和原因
4. 提供有用的建议或总结

回答："""

def query_llm_with_context(prompt: str) -> str:
    """
    使用LLM进行查询
    
    Args:
        prompt: 查询提示词
        
    Returns:
        str: LLM的回答
    """
    response = llm.invoke(prompt)
    return response.content

def query_rider_info(user_question: str, file_path: str = "./data/CA7044794619转换后.txt") -> str:
    """
    根据用户问题查询骑手相关信息
    
    Args:
        user_question: 用户问题
        file_path: 数据文件路径
        
    Returns:
        str: 查询结果
    """
    try:
        # 检测是否为成本相关问题
        if detect_cost_related_question(user_question):
            print("检测到成本相关问题，使用成本分析...")
            return analyze_rider_cost(user_question, file_path)
        
        # 执行相似性搜索
        docs = perform_similarity_search(user_question)
        
        if not docs:
            return "未找到相关信息，请检查问题描述或数据源。"
        
        # 创建上下文和提示词
        context = create_context_from_docs(docs)
        prompt = create_analysis_prompt(user_question, context)
        
        # 查询LLM并返回结果
        return query_llm_with_context(prompt)
        
    except Exception as e:
        error_msg = f"处理查询时出错: {e}"
        print(error_msg)
        return error_msg

def analyze_rider_cost(user_question: str, file_path: str = "./data/CA7044794619转换后.txt") -> str:
    """
    分析骑手成本相关的问题
    
    Args:
        user_question: 用户问题
        file_path: 数据文件路径
        
    Returns:
        str: 成本分析结果
    """
    try:
        # 加载和分割文档
        documents, splits = load_document_and_split(file_path)
        
        if not documents:
            return "无法加载文档数据"
        
        # 提取成本信息
        content = documents[0].page_content
        cost_info = extract_rider_cost_info(content)
        
        if not cost_info:
            return "未找到骑手成本信息"
        
        # 执行相似性搜索获取更多上下文
        docs = perform_similarity_search(user_question)
        context = create_context_from_docs(docs)
        
        # 创建包含成本信息的分析提示词
        cost_summary = "\n".join([
            f"骑手{info['rider_id']}: 总成本{info['total_cost']}, 排名{info['rank']}"
            for info in cost_info.values()
        ])
        
        prompt = f"""基于以下骑手成本信息和相关文档，请详细分析用户的问题。

用户问题：{user_question}

骑手成本摘要：
{cost_summary}

相关文档内容：
{context}

请提供详细的成本分析，包括骑手排名、成本差异、影响因素等。

分析结果："""
        
        return query_llm_with_context(prompt)
        
    except Exception as e:
        return f"分析成本时出错: {e}"

# ============================================================================
# 高级查询方法
# ============================================================================

def execute_template_queries(templates: List[str], file_path: str) -> List[Tuple[str, str, int]]:
    """
    执行模板查询列表
    
    Args:
        templates: 查询模板列表
        file_path: 数据文件路径
        
    Returns:
        List[Tuple[str, str, int]]: (模板, 结果, 分数) 的列表
    """
    results = []
    for i, template in enumerate(templates, 1):
        print(f"\n正在尝试查询模板 {i}: {template}")
        try:
            result = query_rider_info(template, file_path)
            score = evaluate_query_result_quality(result, "", [])
            results.append((template, result, score))
            print(f"查询结果质量分数: {score}")
        except Exception as e:
            print(f"查询模板 {i} 执行出错: {e}")
            results.append((template, "", 0))
    return results

def find_best_result(results: List[Tuple[str, str, int]]) -> Tuple[Optional[str], int]:
    """
    从结果列表中找到最佳结果
    
    Args:
        results: (模板, 结果, 分数) 的列表
        
    Returns:
        Tuple[Optional[str], int]: (最佳结果, 最佳分数)
    """
    if not results:
        return None, 0
    
    best_result = None
    best_score = 0
    
    for template, result, score in results:
        if score > best_score:
            best_score = score
            best_result = result
    
    return best_result, best_score

def query_rider_by_id(rider_id: str, file_path: str = "./data/CA7044794619转换后.txt") -> str:
    """
    根据骑手ID自动生成查询提示词并返回分析结果
    
    Args:
        rider_id: 骑手ID
        file_path: 数据文件路径
        
    Returns:
        str: 查询结果
    """
    print(f"=== 骑手 {rider_id} 信息查询 ===")
    
    # 生成查询模板
    templates = generate_rider_query_templates(rider_id)
    
    # 执行模板查询
    results = execute_template_queries(templates, file_path)
    
    # 找到最佳结果
    best_result, best_score = find_best_result(results)
    
    print(f"\n=== 骑手 {rider_id} 最佳查询结果 ===")
    if best_result:
        print(f"最佳结果分数: {best_score}")
        print(f"分析结果:\n{best_result}")
        return best_result
    else:
        no_result_msg = f"未能找到骑手 {rider_id} 的相关信息，可能原因：\n1. 骑手ID不存在于数据中\n2. 数据文件路径不正确\n3. 向量数据库中没有相关信息"
        print(no_result_msg)
        return no_result_msg

def create_combined_comparison_result(rider_id: str, winner_rider_id: str, order_id: str,
                                    rider_info: str, winner_info: str) -> str:
    """
    创建合并的对比分析结果
    
    Args:
        rider_id: 失败骑手ID
        winner_rider_id: 成功骑手ID
        order_id: 订单ID
        rider_info: 失败骑手信息
        winner_info: 成功骑手信息
        
    Returns:
        str: 合并的对比分析结果
    """
    return f"""=== 骑手对比分析结果 ===

【失败骑手 {rider_id} 的情况】
{rider_info}

【成功骑手 {winner_rider_id} 的情况】
{winner_info}

【对比总结】
通过对比可以看出，骑手{rider_id}未能获得订单{order_id}，而骑手{winner_rider_id}成功获得该订单。主要差异可能在于距离、成本、服务区域、订单类型匹配度等因素。建议骑手{rider_id}关注这些方面的改进。"""

def execute_fallback_comparison_queries(rider_id: str, winner_rider_id: str, order_id: str, 
                                      file_path: str) -> Optional[str]:
    """
    执行备用对比查询（分别查询两个骑手）
    
    Args:
        rider_id: 要分析的骑手ID
        winner_rider_id: 成功骑手ID
        order_id: 订单ID
        file_path: 数据文件路径
        
    Returns:
        Optional[str]: 对比结果，如果查询失败则返回None
    """
    print(f"\n尝试分别查询骑手{rider_id}和{winner_rider_id}的信息...")
    
    rider_info = query_rider_info(f"骑手{rider_id}在订单{order_id}中的情况", file_path)
    winner_info = query_rider_info(f"骑手{winner_rider_id}获得订单{order_id}的原因", file_path)
    
    if rider_info and winner_info:
        return create_combined_comparison_result(rider_id, winner_rider_id, order_id, 
                                               rider_info, winner_info)
    return None

def compare_rider_with_winner(rider_id: str, winner_rider_id: str = "50016", 
                            order_id: str = "CA7044794619", 
                            file_path: str = "./data/CA7044794619转换后.txt") -> str:
    """
    将输入的骑手与成功获得订单的骑手进行比较分析
    
    Args:
        rider_id: 要分析的骑手ID
        winner_rider_id: 成功获得订单的骑手ID，默认为50016
        order_id: 订单号，默认为CA7044794619
        file_path: 数据文件路径
        
    Returns:
        str: 比较分析结果
    """
    print(f"=== 骑手对比分析：{rider_id} vs {winner_rider_id} (订单{order_id}) ===")
    
    # 生成对比查询模板
    comparison_queries = generate_comparison_query_templates(rider_id, winner_rider_id, order_id)
    
    best_result = None
    best_score = 0
    
    # 执行对比查询
    for i, query in enumerate(comparison_queries, 1):
        print(f"\n正在尝试比较查询 {i}: {query}")
        try:
            result = query_rider_info(query, file_path)
            score = evaluate_comparison_result_quality(result, rider_id, winner_rider_id, order_id)
            
            if score > best_score:
                best_score = score
                best_result = result
                
            print(f"比较查询质量分数: {score}")
        except Exception as e:
            print(f"比较查询 {i} 执行出错: {e}")
            continue
    
    # 如果没有找到好的比较结果，尝试备用查询
    if not best_result or best_score < 500:
        fallback_result = execute_fallback_comparison_queries(rider_id, winner_rider_id, 
                                                            order_id, file_path)
        if fallback_result and len(fallback_result) > best_score:
            best_result = fallback_result
            best_score = len(fallback_result)
    
    # 返回最终结果
    print(f"\n=== 最终对比分析结果 ===")
    if best_result:
        print(f"分析质量分数: {best_score}")
        print(f"对比结果:\n{best_result}")
        return best_result
    else:
        no_result_msg = f"未能找到骑手 {rider_id} 与 {winner_rider_id} 的有效对比信息。可能原因：\n1. 数据中缺少相关骑手信息\n2. 查询条件不够精确\n3. 向量数据库中没有相关对比数据"
        print(no_result_msg)
        return no_result_msg

# ============================================================================
# 命令行参数处理方法
# ============================================================================

def handle_comparison_command(sys_argv: List[str]) -> bool:
    """
    处理对比分析命令
    
    Args:
        sys_argv: 命令行参数列表
        
    Returns:
        bool: 是否处理了对比命令
    """
    if len(sys_argv) > 1:
        first_arg = sys_argv[1]
        
        # 检查 --compare 参数
        if first_arg == "--compare" and len(sys_argv) > 2:
            rider_id = sys_argv[2]
            print(f"\n骑手对比分析: {rider_id} vs 50016")
            compare_rider_with_winner(rider_id)
            return True
        
        # 检查数字 + --compare 参数
        elif first_arg.isdigit() and len(sys_argv) > 2 and sys_argv[2] == "--compare":
            rider_id = first_arg
            print(f"\n骑手对比分析: {rider_id} vs 50016")
            compare_rider_with_winner(rider_id)
            return True
    
    return False

def handle_rider_id_command(sys_argv: List[str]) -> bool:
    """
    处理骑手ID查询命令
    
    Args:
        sys_argv: 命令行参数列表
        
    Returns:
        bool: 是否处理了骑手ID命令
    """
    if len(sys_argv) > 1:
        first_arg = sys_argv[1]
        
        # 检查纯数字参数
        if first_arg.isdigit():
            rider_id = first_arg
            print(f"\n检测到骑手ID查询: {rider_id}")
            print("提示：如需与成功骑手50016对比，请使用: python test.py --compare {}".format(rider_id))
            query_rider_by_id(rider_id)
            return True
        
        # 检查 --rider-id 参数
        elif first_arg == "--rider-id" and len(sys_argv) > 2:
            rider_id = sys_argv[2]
            print(f"\n骑手ID查询: {rider_id}")
            query_rider_by_id(rider_id)
            return True
    
    return False

def handle_free_text_command(sys_argv: List[str]) -> bool:
    """
    处理自由文本查询命令
    
    Args:
        sys_argv: 命令行参数列表
        
    Returns:
        bool: 是否处理了自由文本命令
    """
    if len(sys_argv) > 1:
        user_question = " ".join(sys_argv[1:])
        print(f"\n用户问题: {user_question}")
        result = query_rider_info(user_question)
        if result:
            print(f"\n问题：{user_question}")
            print(f"答案：{result}")
        return True
    return False

def run_demo_mode() -> None:
    """
    运行演示模式
    """
    print("\n=== 演示模式 ===")
    print("\n1. 传统问题查询演示:")
    
    # 示例查询
    test_questions = [
        "为什么21103这个骑手没有被选中",
        "骑手19523为什么没有接到订单",
        "订单35863807的派送情况"
    ]
    
    results = []
    for i, question in enumerate(test_questions, 1):
        print(f"正在处理问题 {i}: {question}")
        result = query_rider_info(question)
        results.append((i, question, result if result else "未能获取答案"))
    
    # 输出传统查询结果
    print("\n" + "="*60)
    print("传统查询结果汇总")
    print("="*60)
    for i, question, answer in results:
        print(f"\n问题{i}：{question}")
        print(f"答案：{answer[:200]}..." if len(answer) > 200 else f"答案：{answer}")
        if i < len(results):
            print("-" * 40)

# ============================================================================
# 主程序入口
# ============================================================================

def main() -> None:
    """
    主函数：处理命令行参数并执行相应功能
    """
    import sys
    
    print("=== RAG 骑手信息查询系统 ===")
    
    # 按优先级处理命令行参数
    if handle_comparison_command(sys.argv):
        return
    
    if handle_rider_id_command(sys.argv):
        return
    
    if len(sys.argv) > 1:
        handle_free_text_command(sys.argv)
        return
    
    # 默认运行演示模式
    run_demo_mode()

if __name__ == "__main__":
    main()



            